#include <Arduino.h>
#include <SD.h>
#include <SPI.h>
#include <AccelStepper.h>
#include <MultiStepper.h>
#include <Preferences.h>         // 用于保存用户设置
#include "pin_config.h"          // 引脚配置
#include "motion_controller.h"   // 统一电机控制：绘图 + 归零 + 管理功能
#include "pattern_loader.h"
#include "wifi_manager.h"
#include "mqtt_manager.h"        // MQTT管理器
#include "bluetooth_manager.h"   // 蓝牙管理器
#include "led_manager.h"         // LED硬件驱动层
#include "led_control_center.h"  // LED业务逻辑层
#include "device_state_manager.h" // 设备状态管理器
#include "serial_command_handler.h" // 串口命令处理器
#include "button_manager.h"      // 按钮管理器

// 验证引脚配置
VALIDATE_PIN_UNIQUE();

// 创建步进电机对象 - 共享给两个控制器
AccelStepper* thetaMotor;
AccelStepper* rhoMotor;

// 创建控制器对象
MotionController* motionController;    // 统一管理电机：绘图 + 归零 + 管理功能
PatternLoader* patternLoader;
WiFiManager* wifiManager;
MQTTManager* mqttManager;              // MQTT管理器
BluetoothManager* bluetoothManager;    // 蓝牙管理器
LEDManager* ledManager;                // LED硬件驱动层
LEDControlCenter* ledControlCenter;    // LED业务逻辑层
DeviceStateManager* deviceStateManager; // 设备状态管理器
SerialCommandHandler* serialCommandHandler; // 串口命令处理器
ButtonManager* buttonManager;            // 按钮管理器

// 用户设置持久化存储
Preferences preferences;

// WiFi优先策略控制变量
unsigned long wifiConfigStartTime = 0;
bool hasTriedBluetooth = false;
const unsigned long WIFI_CONFIG_TIMEOUT = 3 * 60 * 1000; // 3分钟超时

// 短按start/stop功能变量
bool isDrawingActive = false;                      // 全局绘图状态标志

// 暂停恢复功能变量
bool isDrawingPaused = false;                      // 是否处于暂停状态
int pausedAtIndex = 0;                             // 暂停时的绘制索引
bool isStreamMode = false;                         // 是否为流式模式（用于恢复）

// 系统开关功能变量
bool systemPowerEnabled = true;            // 系统电源状态（true=启用，false=禁用）

// LED控制变量
unsigned long lastLEDBlink = 0;
bool ledState = false;

// 状态报告变量
unsigned long lastStatusReport = 0;
bool enablePeriodicStatus = false;  // 是否启用定期状态报告
unsigned long statusReportInterval = 60000;  // 默认60秒报告一次

// 标定过程变量
long lastCalibrationSteps = 0;  // 记录最后一次标定执行的步数

// 函数声明
void updateLEDStatus();
bool isSystemPowerEnabled();

// ==================== 初始化函数 ====================

void setup() {
  Serial.begin(115200);
  delay(2000);
  
  Serial.println("🚀 ESP32沙画机启动中...");
  Serial.println("📋 系统初始化开始");
  
  // 初始化引脚
  Serial.println("🔧 初始化引脚配置...");
  
  // 初始化角度电机引脚 (28BYJ-48)
  pinMode(THETA_IN1_PIN, OUTPUT);
  pinMode(THETA_IN2_PIN, OUTPUT);
  pinMode(THETA_IN3_PIN, OUTPUT);
  pinMode(THETA_IN4_PIN, OUTPUT);
  
  // 初始化半径电机引脚 (28BYJ-48)
  pinMode(RHO_IN1_PIN, OUTPUT);
  pinMode(RHO_IN2_PIN, OUTPUT);
  pinMode(RHO_IN3_PIN, OUTPUT);
  pinMode(RHO_IN4_PIN, OUTPUT);
  
  // 初始化限位开关
  pinMode(THETA_HOME_PIN, INPUT_PULLUP);
  pinMode(RHO_HOME_PIN, INPUT_PULLUP);
  
  // 初始化LED硬件驱动层
  Serial.println("💡 初始化LED硬件驱动层...");
  ledManager = new LEDManager(STATUS_LED_PIN, WS2812_PIN, 144);
  if (ledManager != NULL) {
    ledManager->begin();
    Serial.println("✅ LED硬件驱动层初始化成功");
  } else {
    Serial.println("❌ LED硬件驱动层初始化失败");
  }
  
  // 初始化LED业务逻辑层
  Serial.println("🎛️ 初始化LED业务逻辑层...");
  ledControlCenter = new LEDControlCenter(ledManager);
  if (ledControlCenter != NULL && ledControlCenter->begin()) {
    Serial.println("✅ LED业务逻辑层初始化成功");
    Serial.println("🎯 LED双层架构启用：LEDControlCenter(业务) → LEDManager(硬件)");
  } else {
    Serial.println("❌ LED业务逻辑层初始化失败");
  }
  
  // 初始化设备状态管理器
  Serial.println("📊 初始化设备状态管理器...");
  deviceStateManager = new DeviceStateManager();
  if (deviceStateManager != NULL) {
    // 🔧 修复：使用LEDControlCenter而不是LEDManager
    if (deviceStateManager->begin(ledControlCenter)) {
      Serial.println("✅ 设备状态管理器初始化成功");
    } else {
      Serial.println("❌ 设备状态管理器初始化失败");
    }
  } else {
    Serial.println("❌ 设备状态管理器创建失败");
  }
  
  // 创建步进电机对象 - 使用28BYJ-48的4线模式
  Serial.println("🎛️ 初始化步进电机...");
  // 注意：28BYJ-48需要使用FULL4WIRE模式
  thetaMotor = new AccelStepper(AccelStepper::FULL4WIRE, THETA_IN1_PIN, THETA_IN3_PIN, THETA_IN2_PIN, THETA_IN4_PIN);
  rhoMotor = new AccelStepper(AccelStepper::FULL4WIRE, RHO_IN1_PIN, RHO_IN3_PIN, RHO_IN2_PIN, RHO_IN4_PIN);
  
  if (thetaMotor != NULL && rhoMotor != NULL) {
    // 只设置基本的位置信息，速度和加速度完全由MotionController管理
    thetaMotor->setCurrentPosition(0);
    rhoMotor->setCurrentPosition(0);
    
    Serial.println("✅ 步进电机基础初始化成功");
    Serial.println("💡 速度和加速度将由MotionController::init()统一设置");
  } else {
    Serial.println("❌ 步进电机初始化失败");
  }
  
  // 注意：StepperController 已整合到 MotionController 中
  // 归零、电机管理、标定等功能现在统一由 MotionController 提供
  Serial.println("🎛️ 步进电机控制已整合到MotionController - 统一管理所有电机功能");
  
  // 初始化运动控制器 - 传递归零引脚参数
  Serial.println("🎯 初始化运动控制器...");
  motionController = new MotionController(thetaMotor, rhoMotor, THETA_HOME_PIN, RHO_HOME_PIN);
  
  if (motionController != NULL) {
    // 🔧 关键修复：调用init()方法应用MotionController的配置
    motionController->init();
    
    // 按照附件验证方案：连接LEDManager到MotionController
    if (ledManager != NULL) {
      motionController->setLEDManager(ledManager);
      Serial.println("✅ MotionController已连接LEDManager - 支持实时位置LED更新和归零LED效果");
    }
    
    // 🎛️ 统一LED架构：连接LEDControlCenter到MotionController
    if (ledControlCenter != NULL) {
      motionController->setLEDControlCenter(ledControlCenter);
      Serial.println("🎛️ MotionController已连接LEDControlCenter");
    }
    
    // 🔧 显示电机自动管理状态（统一到MotionController）
    if (motionController->isAutoMotorManagementEnabled()) {
      Serial.println("🤖 电机自动管理: ✅启用 (30秒空闲后自动断电)");
      Serial.println("💡 可用命令: automanage off (禁用), timeout <秒数> (设置超时), motorstatus (查看状态)");
    } else {
      Serial.println("🤖 电机自动管理: ❌禁用");
      Serial.println("💡 可用命令: automanage on (启用)");
    }
    
    Serial.println("✅ 运动控制器初始化成功");
  } else {
    Serial.println("❌ 运动控制器初始化失败");
  }
  
  // 初始化图案加载器
  Serial.println("📁 初始化图案加载器...");
  patternLoader = new PatternLoader();
  if (patternLoader != NULL) {
    Serial.println("✅ 图案加载器初始化成功");
    
    // 手动初始化SD卡
    Serial.println("💾 正在初始化SD卡...");
    if (patternLoader->initializeSD()) {
      Serial.println("✅ SD卡初始化成功");
      Serial.println("� 图案文件将在首次使用 'start' 命令时自动加载");
      
      // 显示可用图案文件数量
      std::vector<String> files = patternLoader->listPatternFiles();
      int validCount = 0;
      for (const String& file : files) {
        if (file.endsWith(".thr") && !file.startsWith("._")) {
          validCount++;
        }
      }
      Serial.printf("📂 发现 %d 个可用的.thr图案文件\n", validCount);
    } else {
      Serial.println("❌ SD卡初始化失败");
      if (ledControlCenter != NULL) {
        ledControlCenter->requestStatusChange(LED_ERROR, "SD card initialization failed");
      }
    }
  } else {
    Serial.println("❌ 图案加载器初始化失败");
    if (ledControlCenter != NULL) {
      ledControlCenter->requestStatusChange(LED_ERROR, "Pattern loader initialization failed");
    }
  }
  
  // 初始化WiFi管理器 - 修正构造函数调用
  Serial.println("📶 初始化WiFi管理器...");
  // 通过业务逻辑层请求状态变更
  if (ledControlCenter != NULL) {
    ledControlCenter->requestStatusChange(LED_WIFI_CONNECTING, "WiFi initialization");
  }
  
  wifiManager = new WiFiManager(patternLoader, motionController, motionController, ledManager);
  if (wifiManager != NULL) {
    Serial.println("✅ WiFi管理器创建成功");
    // 🎛️ 连接LEDControlCenter
    if (ledControlCenter != NULL) {
      wifiManager->setLEDControlCenter(ledControlCenter);
      Serial.println("🎛️ WiFiManager已连接LEDControlCenter");
    }
    wifiManager->begin();  // 调用begin()方法启动WiFi配置流程
    
    // 检查WiFi连接结果并设置相应的LED状态
    delay(3000);  // 等待WiFi连接完成
    if (WiFi.status() == WL_CONNECTED) {
      Serial.println("✅ WiFi连接成功");
      // 通过业务逻辑层请求状态变更
      if (ledControlCenter != NULL) {
        ledControlCenter->requestStatusChange(LED_WIFI_CONNECTED, "WiFi connected successfully");
      }
    } else {
      Serial.println("⚠️ WiFi连接失败或超时，将使用热点模式");
      if (ledControlCenter != NULL) {
        ledControlCenter->requestStatusChange(LED_WIFI_FAILED, "WiFi connection failed");
      }
    }
  } else {
    Serial.println("❌ WiFi管理器初始化失败");
    if (ledControlCenter != NULL) {
      ledControlCenter->requestStatusChange(LED_ERROR, "WiFi manager initialization failed");
    }
  }
  
  // 初始化MQTT管理器
  Serial.println("🌐 初始化MQTT管理器...");
  if (ledControlCenter != NULL) {
    ledControlCenter->requestStatusChange(LED_INITIALIZING, "MQTT manager initialization");
  }
  
  mqttManager = new MQTTManager(patternLoader, motionController, motionController, ledManager);
  if (mqttManager != NULL) {
    Serial.println("✅ MQTT管理器创建成功");
    mqttManager->begin();  // 调用begin()方法启动MQTT连接
  } else {
    Serial.println("❌ MQTT管理器初始化失败");
    if (ledControlCenter != NULL) {
      ledControlCenter->requestStatusChange(LED_ERROR, "MQTT manager initialization failed");
    }
  }
  
  // 初始化蓝牙管理器（但暂不启用）
  Serial.println("🔵 初始化蓝牙管理器...");
  bluetoothManager = new BluetoothManager();
  if (bluetoothManager != NULL) {
    bluetoothManager->initialize("sandart");
    Serial.println("✅ 蓝牙管理器创建成功");
    Serial.println("🔵 蓝牙管理器已初始化但未启用（WiFi优先策略）");
  } else {
    Serial.println("❌ 蓝牙管理器初始化失败");
  }

  // WiFi优先策略：记录WiFi配网开始时间
  wifiConfigStartTime = millis();
  Serial.println("⏰ 开始WiFi配网模式，蓝牙暂时禁用");
  Serial.println("💡 如果3分钟内未连接WiFi，将切换到蓝牙配网模式");
    
  // 初始化用户设置
  Serial.println("⚙️ 初始化用户设置...");
  preferences.begin("sandart", false);
  Serial.println("✅ 用户设置初始化成功");
  
  // 初始化串口命令处理器 - 简化构造函数调用
  Serial.println("📟 初始化串口命令处理器...");
  // 首先创建CommandExecutor
  CommandExecutor* commandExecutor = new CommandExecutor(
    patternLoader, motionController, wifiManager, ledManager, ledControlCenter, 
    deviceStateManager, &preferences, &systemPowerEnabled,
    &isDrawingActive, &isDrawingPaused, &pausedAtIndex, &isStreamMode
  );
  
  // 然后创建简化的SerialCommandHandler
  serialCommandHandler = new SerialCommandHandler(
    commandExecutor, mqttManager, &isDrawingPaused, NULL, NULL
  );
  
  if (serialCommandHandler != NULL) {
    Serial.println("✅ 串口命令处理器初始化成功");
    
    // 🔥 关键修复：将CommandExecutor设置到MQTT管理器
    if (mqttManager != NULL) {
      CommandExecutor* commandExecutor = serialCommandHandler->getCommandExecutor();
      if (commandExecutor != NULL) {
        mqttManager->setCommandExecutor(commandExecutor);
        Serial.println("✅ MQTT管理器已设置CommandExecutor - 串口和MQTT命令将使用相同逻辑");
        
        // 🔥 关键修复：设置网络任务回调函数，让绘图过程中能处理MQTT消息
        commandExecutor->setNetworkTaskCallback([]() {
          if (mqttManager != NULL) {
            mqttManager->loop();
          }
        });
        Serial.println("✅ CommandExecutor已设置网络任务回调 - 绘图过程中可处理MQTT消息");
        
        // 🎬 设置自动播放功能回调
        Serial.println("🎬 配置自动播放功能...");
        commandExecutor->setAutoPlayCommandCallback([](const String& command) {
          Serial.printf("🎬 自动播放触发命令: %s\n", command.c_str());
          // 通过串口命令处理器执行命令，确保完整的命令处理流程
          if (serialCommandHandler != nullptr) {
            serialCommandHandler->processCommand(command);
          }
        });
        Serial.println("✅ 自动播放回调函数设置成功 - 绘图完成后可自动循环播放");
        
        // 🔵 设置蓝牙命令处理器和WiFi配置处理器
        if (bluetoothManager != NULL) {
          // 设置蓝牙命令处理器，复用串口命令逻辑
          bluetoothManager->setCommandHandler([](const String& command) -> String {
            if (serialCommandHandler) {
              serialCommandHandler->processCommand(command);
              return "Command executed";
            }
            return "Error: Command handler not available";
          });
          
          // 设置WiFi配置处理器
          bluetoothManager->setWiFiConfigHandler([](const String& ssid, const String& password) {
            if (wifiManager) {
              Serial.printf("🔵 蓝牙配置WiFi: %s\n", ssid.c_str());
              wifiManager->connectWiFi(ssid, password);
            }
          });
          
          Serial.println("✅ 蓝牙管理器已设置命令处理器和WiFi配置处理器");
        }
        
      } else {
        Serial.println("❌ 无法从SerialCommandHandler获取CommandExecutor");
      }
    }
  } else {
    Serial.println("❌ 串口命令处理器初始化失败");
  }
  
  // 初始化按钮管理器
  Serial.println("🔘 初始化按钮管理器...");
  buttonManager = new ButtonManager(WFRS_BUTTON_PIN, ledManager, wifiManager,
                                   &systemPowerEnabled, &isDrawingActive, &isDrawingPaused);
  if (buttonManager != NULL) {
    buttonManager->begin();
    // 设置串口命令处理器引用，使按钮能正确调用绘图命令处理逻辑
    buttonManager->setSerialCommandHandler(serialCommandHandler);
    // 🎛️ 连接LEDControlCenter
    if (ledControlCenter != NULL) {
      buttonManager->setLEDControlCenter(ledControlCenter);
      Serial.println("🎛️ ButtonManager已连接LEDControlCenter");
    }
    Serial.println("✅ 按钮管理器初始化成功");
  } else {
    Serial.println("❌ 按钮管理器初始化失败");
  }
  
  Serial.println("🎉 系统初始化完成！");
  
  // 设置初始状态 - 启动后应该显示为空闲状态
  if (ledControlCenter != NULL) {
    ledControlCenter->requestStatusChange(LED_IDLE, "System initialization completed");
    Serial.println("💡 LED状态设置为: 空闲 (浅青色波浪效果)");
  }
}

// ==================== 主循环函数 ====================

void loop() {
  // 处理按钮输入
  if (buttonManager != NULL) {
    buttonManager->update();
  }
  
  // 串口命令处理 - 仅在非绘图状态处理，绘图时由CommandExecutor处理
  if (serialCommandHandler != NULL && Serial.available() && !isDrawingActive) {
    serialCommandHandler->handleSerialInput();
  }
  
  // 🎬 自动播放功能更新 - 检查是否需要触发自动播放
  if (serialCommandHandler != NULL) {
    CommandExecutor* commandExecutor = serialCommandHandler->getCommandExecutor();
    if (commandExecutor != NULL) {
      commandExecutor->updateAutoPlay();
      // 🔧 新增：自动恢复功能更新
      commandExecutor->updateAutoResume();
    }
  }
  
  // WiFi处理
  if (wifiManager != NULL) {
    wifiManager->handleClient();  // 处理WiFi管理器的客户端请求
  }
  
  // MQTT处理
  if (mqttManager != NULL) {
    mqttManager->loop();
  }
  
  // WiFi优先策略检查
  if (!hasTriedBluetooth && bluetoothManager != NULL) {
    // 检查WiFi配网超时
    if (WiFi.status() != WL_CONNECTED && 
        (millis() - wifiConfigStartTime) > WIFI_CONFIG_TIMEOUT) {
      Serial.println("⏰ WiFi配网超时，切换到蓝牙配网模式");
      Serial.println("🔵 启用蓝牙配对模式");
      
      // 启用蓝牙
      bluetoothManager->enable();
      hasTriedBluetooth = true;
      
      // 更新LED状态
      if (ledControlCenter != NULL) {
        ledControlCenter->requestStatusChange(LED_INITIALIZING, "WiFi timeout, switching to Bluetooth");
      }
    }
  }

  // 蓝牙处理
  if (bluetoothManager != NULL) {
    bluetoothManager->update();
  }
  
  // 电机状态更新（现在由MotionController统一管理）
  if (motionController != NULL) {
    // 🔧 关键修复：只检查空闲状态，不要主动更新活动时间
    // updateMotorActivity() 应该只在电机真正有活动时调用
    motionController->checkMotorIdle();
  }
  
  // 运动控制器更新
  if (motionController != NULL) {
    motionController->update();
  }
  
  // LED状态更新（使用业务逻辑层）
  if (ledControlCenter != NULL) {
    ledControlCenter->update();
  }
  
  // 🔥 关键修复：绘图时不延时，确保最高电机更新频率
  bool isDrawing = (motionController != nullptr && motionController->isMovingNow());
  if (!isDrawing) {
    delay(10);  // 只在空闲时延时，节省CPU
  }
  // 绘图时不延时，确保400步/秒的高速电机更新
}

// ==================== 系统控制函数 ====================

bool isSystemPowerEnabled() {
  return systemPowerEnabled;
}

// ==================== LED状态更新函数 ====================

void updateLEDStatus() {
  // 🔧 修复：使用LEDControlCenter进行状态管理
  if (ledControlCenter == NULL) return;
  
  static bool lastWiFiStatus = false;
  bool currentWiFiStatus = (WiFi.status() == WL_CONNECTED);
  
  // 检查WiFi状态变化
  if (currentWiFiStatus != lastWiFiStatus) {
    if (currentWiFiStatus) {
      ledControlCenter->requestStatusChange(LED_WIFI_CONNECTED, "WiFi连接成功");
      Serial.println("✅ WiFi已连接 - LED状态更新");
    } else {
      ledControlCenter->requestStatusChange(LED_WIFI_FAILED, "WiFi连接丢失");
      Serial.println("❌ WiFi连接丢失 - LED状态更新");
    }
    lastWiFiStatus = currentWiFiStatus;
  }
}
